home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Language/OS - Multiplatform Resource Library
/
LANGUAGE OS.iso
/
ast_comp
/
ora-sql.shr
< prev
next >
Wrap
Text File
|
1993-07-04
|
15KB
|
850 lines
#!/bin/sh
#
# This is a SQL lexer and parser based on the grammar in Date's SQL
# book. For more info, see Levine, Mason, and Brown, "lex&yacc," 2nd
# edition, O'Reilly and Associates, where this parser is explained in
# detail in Chapter 5.
#
# I grant anyone permission to reproduce these files in any form. If
# you use it in a commercial product, I'd appreciate credit.
#
# John Levine, johnl@iecc.cambridge.ma.us, October 1992
#
# This is a shell archive (produced by shar 3.49)
# To extract the files from this archive, save it to a file, remove
# everything above the "!/bin/sh" line above, and type "sh file_name".
#
# made 10/31/1992 03:58 UTC by johnl@iecc
# Source directory /usr/johnl/nuts/lyref/code
#
# existing files will NOT be overwritten unless -c is specified
#
# This shar contains:
# length mode name
# ------ ---------- ------------------------------------------
# 9260 -rw-rw-r-- sql1.y
# 3533 -rw-rw-r-- scn1.l
#
# ============= sql1.y ==============
if test -f 'sql1.y' -a X"$1" != X"-c"; then
echo 'x - skipping sql1.y (File already exists)'
else
echo 'x - extracting sql1.y (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'sql1.y' &&
X /* symbolic tokens */
X
%union {
X int intval;
X double floatval;
X char *strval;
X int subtok;
}
X
%token NAME
%token STRING
%token INTNUM APPROXNUM
X
X /* operators */
X
%left OR
%left AND
%left NOT
%left <subtok> COMPARISON /* = <> < > <= >= */
%left '+' '-'
%left '*' '/'
%nonassoc UMINUS
X
X /* literal keyword tokens */
X
%token ALL AMMSC ANY AS ASC AUTHORIZATION BETWEEN BY
%token CHARACTER CHECK CLOSE COMMIT CONTINUE CREATE CURRENT
%token CURSOR DECIMAL DECLARE DEFAULT DELETE DESC DISTINCT DOUBLE
%token ESCAPE EXISTS FETCH FLOAT FOR FOREIGN FOUND FROM GOTO
%token GRANT GROUP HAVING IN INDICATOR INSERT INTEGER INTO
%token IS KEY LANGUAGE LIKE MODULE NULLX NUMERIC OF ON
%token OPEN OPTION ORDER PRECISION PRIMARY PRIVILEGES PROCEDURE
%token PUBLIC REAL REFERENCES ROLLBACK SCHEMA SELECT SET
%token SMALLINT SOME SQLCODE SQLERROR TABLE TO UNION
%token UNIQUE UPDATE USER VALUES VIEW WHENEVER WHERE WITH WORK
%token COBOL FORTRAN PASCAL PLI C ADA
X
%%
X
sql_list:
X sql ';'
X | sql_list sql ';'
X ;
X
X
X /* schema definition language */
X /* Note: other ``sql:'' rules appear later in the grammar */
sql: schema
X ;
X
schema:
X CREATE SCHEMA AUTHORIZATION user opt_schema_element_list
X ;
X
opt_schema_element_list:
X /* empty */
X | schema_element_list
X ;
X
schema_element_list:
X schema_element
X | schema_element_list schema_element
X ;
X
schema_element:
X base_table_def
X | view_def
X | privilege_def
X ;
X
base_table_def:
X CREATE TABLE table '(' base_table_element_commalist ')'
X ;
X
base_table_element_commalist:
X base_table_element
X | base_table_element_commalist ',' base_table_element
X ;
X
base_table_element:
X column_def
X | table_constraint_def
X ;
X
column_def:
X column data_type column_def_opt_list
X ;
X
column_def_opt_list:
X /* empty */
X | column_def_opt_list column_def_opt
X ;
X
column_def_opt:
X NOT NULLX
X | NOT NULLX UNIQUE
X | NOT NULLX PRIMARY KEY
X | DEFAULT literal
X | DEFAULT NULLX
X | DEFAULT USER
X | CHECK '(' search_condition ')'
X | REFERENCES table
X | REFERENCES table '(' column_commalist ')'
X ;
X
table_constraint_def:
X UNIQUE '(' column_commalist ')'
X | PRIMARY KEY '(' column_commalist ')'
X | FOREIGN KEY '(' column_commalist ')'
X REFERENCES table
X | FOREIGN KEY '(' column_commalist ')'
X REFERENCES table '(' column_commalist ')'
X | CHECK '(' search_condition ')'
X ;
X
column_commalist:
X column
X | column_commalist ',' column
X ;
X
view_def:
X CREATE VIEW table opt_column_commalist
X AS query_spec opt_with_check_option
X ;
X
opt_with_check_option:
X /* empty */
X | WITH CHECK OPTION
X ;
X
opt_column_commalist:
X /* empty */
X | '(' column_commalist ')'
X ;
X
privilege_def:
X GRANT privileges ON table TO grantee_commalist
X opt_with_grant_option
X ;
X
opt_with_grant_option:
X /* empty */
X | WITH GRANT OPTION
X ;
X
privileges:
X ALL PRIVILEGES
X | ALL
X | operation_commalist
X ;
X
operation_commalist:
X operation
X | operation_commalist ',' operation
X ;
X
operation:
X SELECT
X | INSERT
X | DELETE
X | UPDATE opt_column_commalist
X | REFERENCES opt_column_commalist
X ;
X
X
grantee_commalist:
X grantee
X | grantee_commalist ',' grantee
X ;
X
grantee:
X PUBLIC
X | user
X ;
X
X /* module language */
sql: module_def
X ;
X
module_def:
X MODULE opt_module
X LANGUAGE lang
X AUTHORIZATION user
X opt_cursor_def_list
X procedure_def_list
X ;
X
opt_module:
X /* empty */
X | module
X ;
X
lang:
X COBOL
X | FORTRAN
X | PASCAL
X | PLI
X | C
X | ADA
X ;
X
opt_cursor_def_list:
X /* empty */
X | cursor_def_list
X ;
X
cursor_def_list:
X cursor_def
X | cursor_def_list cursor_def
X ;
X
cursor_def:
X DECLARE cursor CURSOR FOR query_exp opt_order_by_clause
X ;
X
opt_order_by_clause:
X /* empty */
X | ORDER BY ordering_spec_commalist
X ;
X
ordering_spec_commalist:
X ordering_spec
X | ordering_spec_commalist ',' ordering_spec
X ;
X
ordering_spec:
X INTNUM opt_asc_desc
X | column_ref opt_asc_desc
X ;
X
opt_asc_desc:
X /* empty */
X | ASC
X | DESC
X ;
X
procedure_def_list:
X procedure_def
X | procedure_def_list procedure_def
X ;
X
procedure_def:
X PROCEDURE procedure parameter_def_list ';'
X manipulative_statement_list
X ;
X
manipulative_statement_list:
X manipulative_statement
X | manipulative_statement_list manipulative_statement
X ;
X
parameter_def_list:
X parameter_def
X | parameter_def_list parameter_def
X ;
X
parameter_def:
X parameter data_type
X | SQLCODE
X ;
X
X /* manipulative statements */
X
sql: manipulative_statement
X ;
X
manipulative_statement:
X close_statement
X | commit_statement
X | delete_statement_positioned
X | delete_statement_searched
X | fetch_statement
X | insert_statement
X | open_statement
X | rollback_statement
X | select_statement
X | update_statement_positioned
X | update_statement_searched
X ;
X
close_statement:
X CLOSE cursor
X ;
X
commit_statement:
X COMMIT WORK
X ;
X
delete_statement_positioned:
X DELETE FROM table WHERE CURRENT OF cursor
X ;
X
delete_statement_searched:
X DELETE FROM table opt_where_clause
X ;
X
fetch_statement:
X FETCH cursor INTO target_commalist
X ;
X
insert_statement:
X INSERT INTO table opt_column_commalist values_or_query_spec
X ;
X
values_or_query_spec:
X VALUES '(' insert_atom_commalist ')'
X | query_spec
X ;
X
insert_atom_commalist:
X insert_atom
X | insert_atom_commalist ',' insert_atom
X ;
X
insert_atom:
X atom
X | NULLX
X ;
X
open_statement:
X OPEN cursor
X ;
X
rollback_statement:
X ROLLBACK WORK
X ;
X
select_statement:
X SELECT opt_all_distinct selection
X INTO target_commalist
X table_exp
X ;
X
opt_all_distinct:
X /* empty */
X | ALL
X | DISTINCT
X ;
X
update_statement_positioned:
X UPDATE table SET assignment_commalist
X WHERE CURRENT OF cursor
X ;
X
assignment_commalist:
X | assignment
X | assignment_commalist ',' assignment
X ;
X
assignment:
X column '=' scalar_exp
X | column '=' NULLX
X ;
X
update_statement_searched:
X UPDATE table SET assignment_commalist opt_where_clause
X ;
X
target_commalist:
X target
X | target_commalist ',' target
X ;
X
target:
X parameter_ref
X ;
X
opt_where_clause:
X /* empty */
X | where_clause
X ;
X
X /* query expressions */
X
query_exp:
X query_term
X | query_exp UNION query_term
X | query_exp UNION ALL query_term
X ;
X
query_term:
X query_spec
X | '(' query_exp ')'
X ;
X
query_spec:
X SELECT opt_all_distinct selection table_exp
X ;
X
selection:
X scalar_exp_commalist
X | '*'
X ;
X
table_exp:
X from_clause
X opt_where_clause
X opt_group_by_clause
X opt_having_clause
X ;
X
from_clause:
X FROM table_ref_commalist
X ;
X
table_ref_commalist:
X table_ref
X | table_ref_commalist ',' table_ref
X ;
X
table_ref:
X table
X | table range_variable
X ;
X
where_clause:
X WHERE search_condition
X ;
X
opt_group_by_clause:
X /* empty */
X | GROUP BY column_ref_commalist
X ;
X
column_ref_commalist:
X column_ref
X | column_ref_commalist ',' column_ref
X ;
X
opt_having_clause:
X /* empty */
X | HAVING search_condition
X ;
X
X /* search conditions */
X
search_condition:
X | search_condition OR search_condition
X | search_condition AND search_condition
X | NOT search_condition
X | '(' search_condition ')'
X | predicate
X ;
X
predicate:
X comparison_predicate
X | between_predicate
X | like_predicate
X | test_for_null
X | in_predicate
X | all_or_any_predicate
X | existence_test
X ;
X
comparison_predicate:
X scalar_exp COMPARISON scalar_exp
X | scalar_exp COMPARISON subquery
X ;
X
between_predicate:
X scalar_exp NOT BETWEEN scalar_exp AND scalar_exp
X | scalar_exp BETWEEN scalar_exp AND scalar_exp
X ;
X
like_predicate:
X scalar_exp NOT LIKE atom opt_escape
X | scalar_exp LIKE atom opt_escape
X ;
X
opt_escape:
X /* empty */
X | ESCAPE atom
X ;
X
test_for_null:
X column_ref IS NOT NULLX
X | column_ref IS NULLX
X ;
X
in_predicate:
X scalar_exp NOT IN '(' subquery ')'
X | scalar_exp IN '(' subquery ')'
X | scalar_exp NOT IN '(' atom_commalist ')'
X | scalar_exp IN '(' atom_commalist ')'
X ;
X
atom_commalist:
X atom
X | atom_commalist ',' atom
X ;
X
all_or_any_predicate:
X scalar_exp COMPARISON any_all_some subquery
X ;
X
any_all_some:
X ANY
X | ALL
X | SOME
X ;
X
existence_test:
X EXISTS subquery
X ;
X
subquery:
X '(' SELECT opt_all_distinct selection table_exp ')'
X ;
X
X /* scalar expressions */
X
scalar_exp:
X scalar_exp '+' scalar_exp
X | scalar_exp '-' scalar_exp
X | scalar_exp '*' scalar_exp
X | scalar_exp '/' scalar_exp
X | '+' scalar_exp %prec UMINUS
X | '-' scalar_exp %prec UMINUS
X | atom
X | column_ref
X | function_ref
X | '(' scalar_exp ')'
X ;
X
scalar_exp_commalist:
X scalar_exp
X | scalar_exp_commalist ',' scalar_exp
X ;
X
atom:
X parameter_ref
X | literal
X | USER
X ;
X
parameter_ref:
X parameter
X | parameter parameter
X | parameter INDICATOR parameter
X ;
X
function_ref:
X AMMSC '(' '*' ')'
X | AMMSC '(' DISTINCT column_ref ')'
X | AMMSC '(' ALL scalar_exp ')'
X | AMMSC '(' scalar_exp ')'
X ;
X
literal:
X STRING
X | INTNUM
X | APPROXNUM
X ;
X
X /* miscellaneous */
X
table:
X NAME
X | NAME '.' NAME
X ;
X
column_ref:
X NAME
X | NAME '.' NAME /* needs semantics */
X | NAME '.' NAME '.' NAME
X ;
X
X /* data types */
X
data_type:
X CHARACTER
X | CHARACTER '(' INTNUM ')'
X | NUMERIC
X | NUMERIC '(' INTNUM ')'
X | NUMERIC '(' INTNUM ',' INTNUM ')'
X | DECIMAL
X | DECIMAL '(' INTNUM ')'
X | DECIMAL '(' INTNUM ',' INTNUM ')'
X | INTEGER
X | SMALLINT
X | FLOAT
X | FLOAT '(' INTNUM ')'
X | REAL
X | DOUBLE PRECISION
X ;
X
X /* the various things you can name */
X
column: NAME
X ;
X
cursor: NAME
X ;
X
module: NAME
X ;
X
parameter:
X ':' NAME
X ;
X
procedure: NAME
X ;
X
range_variable: NAME
X ;
X
user: NAME
X ;
X
X /* embedded condition things */
sql: WHENEVER NOT FOUND when_action
X | WHENEVER SQLERROR when_action
X ;
X
when_action: GOTO NAME
X | CONTINUE
X ;
%%
SHAR_EOF
chmod 0664 sql1.y ||
echo 'restore of sql1.y failed'
Wc_c="`wc -c < 'sql1.y'`"
test 9260 -eq "$Wc_c" ||
echo 'sql1.y: original size 9260, current size' "$Wc_c"
fi
# ============= scn1.l ==============
if test -f 'scn1.l' -a X"$1" != X"-c"; then
echo 'x - skipping scn1.l (File already exists)'
else
echo 'x - extracting scn1.l (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'scn1.l' &&
%{
/*
X * AT&T lex can't handle this lexer due to lex bugs. It works with flex
X * 2.3.7, pclex 2.0.5, and MKS lex 3.1a.
X */
X
#include "sql1.h"
#include <string.h>
X
int lineno = 1;
void yyerror(char *s);
%}
X /* MKS needs the next line to increase the NFA table */
%e 1200
X
%%
X
X /* literal keyword tokens */
X
ADA { return ADA; }
ALL { return ALL; }
AND { return AND; }
AVG { return AMMSC; }
MIN { return AMMSC; }
MAX { return AMMSC; }
SUM { return AMMSC; }
COUNT { return AMMSC; }
ANY { return ANY; }
AS { return AS; }
ASC { return ASC; }
AUTHORIZATION { return AUTHORIZATION; }
BETWEEN { return BETWEEN; }
BY { return BY; }
C { return C; }
CHAR(ACTER)? { return CHARACTER; }
CHECK { return CHECK; }
CLOSE { return CLOSE; }
COBOL { return COBOL; }
COMMIT { return COMMIT; }
CONTINUE { return CONTINUE; }
CREATE { return CREATE; }
CURRENT { return CURRENT; }
CURSOR { return CURSOR; }
DECIMAL { return DECIMAL; }
DECLARE { return DECLARE; }
DEFAULT { return DEFAULT; }
DELETE { return DELETE; }
DESC { return DESC; }
DISTINCT { return DISTINCT; }
DOUBLE { return DOUBLE; }
ESCAPE { return ESCAPE; }
EXISTS { return EXISTS; }
FETCH { return FETCH; }
FLOAT { return FLOAT; }
FOR { return FOR; }
FOREIGN { return FOREIGN; }
FORTRAN { return FORTRAN; }
FOUND { return FOUND; }
FROM { return FROM; }
GO[ \t]*TO { return GOTO; }
GRANT { return GRANT; }
GROUP { return GROUP; }
HAVING { return HAVING; }
IN { return IN; }
INDICATOR { return INDICATOR; }
INSERT { return INSERT; }
INT(EGER)? { return INTEGER; }
INTO { return INTO; }
IS { return IS; }
KEY { return KEY; }
LANGUAGE { return LANGUAGE; }
LIKE { return LIKE; }
MODULE { return MODULE; }
NOT { return NOT; }
NULL { return NULLX; }
NUMERIC { return NUMERIC; }
OF { return OF; }
ON { return ON; }
OPEN { return OPEN; }
OPTION { return OPTION; }
OR { return OR; }
ORDER { return ORDER; }
PASCAL { return PASCAL; }
PLI { return PLI; }
PRECISION { return PRECISION; }
PRIMARY { return PRIMARY; }
PRIVILEGES { return PRIVILEGES; }
PROCEDURE { return PROCEDURE; }
PUBLIC { return PUBLIC; }
REAL { return REAL; }
REFERENCES { return REFERENCES; }
ROLLBACK { return ROLLBACK; }
SCHEMA { return SCHEMA; }
SELECT { return SELECT; }
SET { return SET; }
SMALLINT { return SMALLINT; }
SOME { return SOME; }
SQLCODE { return SQLCODE; }
TABLE { return TABLE; }
TO { return TO; }
UNION { return UNION; }
UNIQUE { return UNIQUE; }
UPDATE { return UPDATE; }
USER { return USER; }
VALUES { return VALUES; }
VIEW { return VIEW; }
WHENEVER { return WHENEVER; }
WHERE { return WHERE; }
WITH { return WITH; }
WORK { return WORK; }
X
X /* punctuation */
X
"=" |
"<>" |
"<" |
">" |
"<=" |
">=" { return COMPARISON; }
X
[-+*/:(),.;] { return yytext[0]; }
X
X /* names */
X
[A-Za-z][A-Za-z0-9_]* { return NAME; }
X
X /* numbers */
X
[0-9]+ |
[0-9]+"."[0-9]* |
"."[0-9]* { return INTNUM; }
X
[0-9]+[eE][+-]?[0-9]+ |
[0-9]+"."[0-9]*[eE][+-]?[0-9]+ |
"."[0-9]*[eE][+-]?[0-9]+ { return APPROXNUM; }
X
X /* strings */
X
'[^'\n]*' {
X int c = input();
X
X unput(c); /* just peeking */
X if(c != '\'') {
X return STRING;
X } else
X yymore();
X }
X
'[^'\n]*$ { yyerror("Unterminated string"); }
X
\n lineno++;
X
[ \t\r]+ ; /* white space */
X
"--".*$ ; /* comment */
X
%%
X
void
yyerror(char *s)
{
X printf("%d: %s at %s\n", lineno, s, yytext);
}
X
main(int ac, char **av)
{
X if(ac > 1 && (yyin = fopen(av[1], "r")) == NULL) {
X perror(av[1]);
X exit(1);
X }
X
X if(!yyparse())
X printf("SQL parse worked\n");
X else
X printf("SQL parse failed\n");
} /* main */
SHAR_EOF
chmod 0664 scn1.l ||
echo 'restore of scn1.l failed'
Wc_c="`wc -c < 'scn1.l'`"
test 3533 -eq "$Wc_c" ||
echo 'scn1.l: original size 3533, current size' "$Wc_c"
fi
exit 0